/**
 *	@brief	ポケギアマップ BG描画
 *	@author	Miyuki Iwasawa
 *	@date	07.06.20
 */

#include "common.h"
#include "system/procsys.h"
#include "system/arc_util.h"
#include "system/arc_tool.h"
#include "system/brightness.h"
#include "system/bmp_list.h"
#include "system/bmp_menu.h"
#include "system/pm_str.h"
#include "system/msgdata.h"
#include "system/fontproc.h"
#include "system/snd_tool.h"
#include "system/clact_util.h"
#include "system/clact_tool.h"
#include "system/render_oam.h"
#include "system/wipe.h"
#include "system/buflen.h"
#include "system/palanm.h"
#include "gflib/touchpanel.h"
#include "field/field_matrix.h"
#include "field/field_place_name.h"
#include "application/app_tool.h"
#include "application/pokegear.h"
#include "msgdata/msg.naix"

#include "../pgear_sys.h"
#include "../pgear_frm.h"
#include "../pgear_act.h"
#include "pgmap_sys.h"

#define __BGMAP_BG_H_GLOBAL
#include "pgmap_bg.h"
#include "pgmap_sub.h"

//===========================================================================
///プロトタイプ
//===========================================================================
static void pgmap_BGLInit(PGMAP_SYS_WORK* wk);
static void pgmap_BGLRelease(PGMAP_SYS_WORK* wk);
static void pgmap_2DResInit(PGMAP_SYS_WORK* wk,u8 skin);
static void pgmap_2DResRelease(PGMAP_SYS_WORK* wk);
static void pgmap_BmpWinAdd(PGMAP_SYS_WORK* wk);
static void pgmap_BmpWinDel(PGMAP_SYS_WORK* wk);
static void pgmap_MsgDataInit(PGMAP_SYS_WORK* wk);
static void pgmap_MsgDataRelease(PGMAP_SYS_WORK* wk);
static void pgmap_PalAnmWorkSet(PGMAP_SYS_WORK* wk,u8 skin);
static void pgmap_CMoveParamInit(PGMAP_SYS_WORK* wk);
static void pgmap_CMoveParamRelease(PGMAP_SYS_WORK* wk);
static void pgmap_ActResInit(PGMAP_SYS_WORK* wk);
static void pgmap_ActResRelease(PGMAP_SYS_WORK* wk);
static void pgmap_MakeActor(PGMAP_SYS_WORK* wk);
static void pgmap_DelMEditActor(PGMAP_SYS_WORK* wk);
static void pgmap_DelUncommonActor(PGMAP_SYS_WORK* wk);
static void pgmap_DelActorAll(PGMAP_SYS_WORK* wk);
static void pgmap_MapIniDraw(PGMAP_SYS_WORK* wk);
static void pgmap_MarkViewIniDraw(PGMAP_SYS_WORK* wk);
static void pgmap_MarkViewDataSet(PGMAP_SYS_WORK* wk,BOOL on_f);

//===========================================================================
///プログラムエリア
//===========================================================================
/**
 *	@brief	マップの初期化
 */
int PGMap_AppInit(PGMAP_SYS_WORK* wk)
{
	switch(wk->sub_seq){
	case 0:
		//2Dリソース初期化
		pgmap_BGLInit(wk);
		break;
	case 1:
		pgmap_2DResInit(wk,wk->sys->skin_id);
		pgmap_BmpWinAdd(wk);
		pgmap_MsgDataInit(wk);
		break;
	case 2:
		//アクターリソース作成
		pgmap_ActResInit(wk);
		//アクター生成前にパレットをセット
		pgmap_PalAnmWorkSet(wk,wk->sys->skin_id);
		pgmap_MakeActor(wk);
		break;
	case 3:
		//初期画面構築
		if(wk->call_mode == PGMAP_CALL_MARK){
			pgmap_MarkViewIniDraw(wk);
		}else{
			pgmap_MapIniDraw(wk);
		}

		//アプリVBlank関数登録
		wk->sys->app_vfunc = PGMapSub_VBlank;
		wk->sub_seq = 0;
		return TRUE;
	}
	++wk->sub_seq;
	return FALSE;
}

/**
 *	@brief	マップの開放
 */
int PGMap_AppEnd(PGMAP_SYS_WORK* wk)
{
	//アプリVBlank関数登録削除
	wk->sys->app_vfunc = NULL;

	if(wk->sys->next_mode == PG_NEXT_WORD){
		pgmap_CMoveParamRelease(wk);
		pgmap_DelMEditActor(wk);
	}
	pgmap_DelActorAll(wk);
	pgmap_ActResRelease(wk);
	pgmap_MsgDataRelease(wk);
	pgmap_BmpWinDel(wk);
	pgmap_2DResRelease(wk);
	pgmap_BGLRelease(wk);
	return TRUE;
}

/**
 *	@brief	マーク画面の初期化
 */
int PGMap_MarkInit(PGMAP_SYS_WORK* wk)
{
	int flag1,flag2;

	switch(wk->sub_seq){
	case 0:
		//保存パラメータをPush
		PGMapSub_MapParamPush(wk);

		//上画面の初期スクロール値をセットする
		PGMapSub_GuideScrollSet(wk,1);

		//下画面のフェードアウトをセットする
		WIPE_SYS_Start(WIPE_PATTERN_M,
				WIPE_TYPE_FADEOUT,
				WIPE_TYPE_FADEOUT,0x0000,COMM_BRIGHTNESS_SYNC,1,wk->heapID);
		break;
	case 1:
		//フェード&スクロール待ち
		flag1 = WIPE_SYS_EndCheck();
		flag2 = PGMapSub_GuideScrollWait(wk,1);
		if(!flag1 || !flag2){
			return FALSE;
		}

		//非コモンアクターをいったん削除
		pgmap_DelUncommonActor(wk);
		break;
	case 2:
		//マーキング画面を構築
		pgmap_MarkViewDataSet(wk,TRUE);
		pgmap_MarkViewIniDraw(wk);
		WIPE_SYS_Start(WIPE_PATTERN_M,
				WIPE_TYPE_FADEIN,
				WIPE_TYPE_FADEIN,0x0000,COMM_BRIGHTNESS_SYNC,1,wk->heapID);

		//スクロール初期位置セット
		PGMapSub_MarkScrollSet(wk,0);
		break;
	case 3:
		//フェードイン待ち
		if(!WIPE_SYS_EndCheck()){
			return FALSE;
		}
		Snd_SePlay(SE_PGEAR_MAP_Y);
		break;
	case 4:
		//スクロール待ち
		if(!PGMapSub_MarkScrollWait(wk,0)){
			return FALSE;
		}
		wk->sub_seq = 0;
		return TRUE;
	}
	wk->sub_seq++;
	return FALSE;
}

/**
 *	@brief	マーク編集画面からマップ画面へ戻る
 */
int PGMap_MarkReturn(PGMAP_SYS_WORK* wk)
{
	int flag1,flag2;

	switch(wk->sub_seq){
	case 0:
		//スクロール初期位置セット
		PGMapSub_MarkScrollSet(wk,1);
		Snd_SePlay(SE_PGEAR_MAP_Y);
		break;
	case 1:
		//スクロール待ち
		if(!PGMapSub_MarkScrollWait(wk,1)){
			return FALSE;
		}
		//下画面のフェードアウトをセットする
		WIPE_SYS_Start(WIPE_PATTERN_M,
				WIPE_TYPE_FADEOUT,
				WIPE_TYPE_FADEOUT,0x0000,COMM_BRIGHTNESS_SYNC,1,wk->heapID);
		break;
	case 2:
		//フェードアウト待ち
		if(!WIPE_SYS_EndCheck()){
			return FALSE;
		}
		//非コモンデータをいったん削除
		pgmap_CMoveParamRelease(wk);
		pgmap_DelMEditActor(wk);
		break;
	case 3:
		//データ復帰
		pgmap_MarkViewDataSet(wk,FALSE);
		//マップ画面復帰(パラメータのpopを内部でやっている)
		pgmap_MapIniDraw(wk);

		//サブ画面の初期スクロール値をセットする
		PGMapSub_GuideScrollSet(wk,0);
		WIPE_SYS_Start(WIPE_PATTERN_M,
				WIPE_TYPE_FADEIN,
				WIPE_TYPE_FADEIN,0x0000,COMM_BRIGHTNESS_SYNC,1,wk->heapID);
		break;
	case 4:
		//フェード&スクロール待ち
		flag1 = WIPE_SYS_EndCheck();
		flag2 = PGMapSub_GuideScrollWait(wk,0);
		if(!flag1 || !flag2){
			return FALSE;
		}
		wk->sub_seq = 0;
		return TRUE;
	}
	wk->sub_seq++;
	return FALSE;
}



/**
 *	@brief	マップのBGL初期化
 */
static void pgmap_BGLInit(PGMAP_SYS_WORK* wk)
{
	int i;
	PGEAR_SYS_WORK *sys = wk->sys;

	//メインのBGモードをtext,text,affineEx,affineExのMode5に変更
	{
		//GFルールでは直接呼ぶべきではないが、ポケギアでは特別に呼ぶ
		GX_SetGraphicsMode( GX_DISPMODE_GRAPHICS, GX_BGMODE_5,GX_BG0_AS_2D );
	}

	{	//BG0はフレームの占有領域なのでいじらないこと！
		GF_BGL_BGCNT_HEADER TextBgCntDat[] = {
		{	//MAIN BG1
			0,0,0x800,0,GF_BGL_SCRSIZ_256x256,GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xf000,GX_BG_CHARBASE_0x00000,GX_BG_EXTPLTT_01,
			1,0,0,FALSE},
		{	//MAIN BG2
			0,0,0x2000,0,GF_BGL_SCRSIZ_512x512,GX_BG_COLORMODE_256,
			GX_BG_SCRBASE_0xd000,GX_BG_CHARBASE_0x10000,GX_BG_EXTPLTT_01,
			2,0,0,FALSE},
		{	//MAIN BG3
			0,0,0x2000,0,GF_BGL_SCRSIZ_512x512,GX_BG_COLORMODE_256,
			GX_BG_SCRBASE_0xb000,GX_BG_CHARBASE_0x10000,GX_BG_EXTPLTT_01,
			3,0,0,FALSE},
		{	//SUB BG1
			0,0,0x800,0,GF_BGL_SCRSIZ_256x256,GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xf000,GX_BG_CHARBASE_0x00000,GX_BG_EXTPLTT_01,
			0,0,0,FALSE},
		{	//SUB BG2
			0,0,0x800,0,GF_BGL_SCRSIZ_256x256,GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xe800,GX_BG_CHARBASE_0x00000,GX_BG_EXTPLTT_01,
			1,0,0,FALSE},
		{	//SUB BG3
			0,0,0x800,0,GF_BGL_SCRSIZ_256x256,GX_BG_COLORMODE_16,
			GX_BG_SCRBASE_0xe000,GX_BG_CHARBASE_0x10000,GX_BG_EXTPLTT_01,
			2,0,0,FALSE},
		};
		GF_BGL_BGControlSetEx(wk->sys->bgl,GF_BGL_FRAME1_M,&(TextBgCntDat[0]),GF_BGL_MODE_TEXT,VISIBLE_OFF);
		GF_BGL_BGControlSetEx(wk->sys->bgl,GF_BGL_FRAME2_M,&(TextBgCntDat[1]),GF_BGL_MODE_256X16,VISIBLE_OFF);
		GF_BGL_BGControlSetEx(wk->sys->bgl,GF_BGL_FRAME3_M,&(TextBgCntDat[2]),GF_BGL_MODE_256X16,VISIBLE_OFF);
		GF_BGL_BGControlSetEx(wk->sys->bgl,GF_BGL_FRAME1_S,&(TextBgCntDat[3]),GF_BGL_MODE_TEXT,VISIBLE_OFF);
		GF_BGL_BGControlSetEx(wk->sys->bgl,GF_BGL_FRAME2_S,&(TextBgCntDat[4]),GF_BGL_MODE_TEXT,VISIBLE_OFF);
		GF_BGL_BGControlSetEx(wk->sys->bgl,GF_BGL_FRAME3_S,&(TextBgCntDat[5]),GF_BGL_MODE_TEXT,VISIBLE_OFF);

		for(i = 0;i < 3;i++){
			GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME1_M+i);
			GF_BGL_ClearCharSet(GF_BGL_FRAME1_M+i,64,0,wk->heapID);
			GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME1_S+i);
			GF_BGL_ClearCharSet(GF_BGL_FRAME1_S+i,32,0,wk->heapID);
			GF_BGL_LoadScreenReq(wk->sys->bgl,GF_BGL_FRAME1_M+i);
			GF_BGL_LoadScreenReq(wk->sys->bgl,GF_BGL_FRAME1_S+i);
		}
	}

}

/**
 *	@brief	マップBGL開放
 *
 */
static void pgmap_BGLRelease(PGMAP_SYS_WORK* wk)
{
	PGFrame_LocalVramClear(wk->sys);
#if 0
	//ローカルパレット領域をクリア
	GF_BGL_ClearPaletteSet(GF_BGL_FRAME1_M,0x20*PGAPP_PALNUM_M,0 ,wk->heapID);
	GF_BGL_ClearPaletteSet(GF_BGL_FRAME1_S,0x20*PGAPP_PALNUM_S,0 ,wk->heapID);

	GF_BGL_BGControlExit( sys->bgl,GF_BGL_FRAME3_S);
	GF_BGL_BGControlExit( sys->bgl,GF_BGL_FRAME2_S);
	GF_BGL_BGControlExit( sys->bgl,GF_BGL_FRAME1_S);
	GF_BGL_BGControlExit( sys->bgl,GF_BGL_FRAME3_M);
	GF_BGL_BGControlExit( sys->bgl,GF_BGL_FRAME2_M);
	GF_BGL_BGControlExit( sys->bgl,GF_BGL_FRAME1_M);
#endif
	//ブレンド設定解除
	G2_SetBlendAlpha(GX_BLEND_PLANEMASK_NONE,GX_BLEND_PLANEMASK_NONE,0,0);
}

/**
 *	@brief	マップのBGリソース初期化
 */
static void pgmap_2DResInit(PGMAP_SYS_WORK* wk,u8 skin)
{
	int	arcID;
	ARCHANDLE* handle;

	//アーカイブハンドル取得
	arcID = ARC_PGMAP_GRA;
	handle = ArchiveDataHandleOpen(ARC_PGMAP_GRA,wk->heapID);

	//キャラクタ転送
	APP_ArcFileVramLoad(wk->sys->bgl,wk->heapID,
		handle,arcID,NARC_pgmap_gra_frm001_ncgr+skin,
		GF_BGL_FRAME1_M,0,0,0);

	APP_ArcFileVramLoad(wk->sys->bgl,wk->heapID,
		handle,arcID,NARC_pgmap_gra_map_ncgr,
		GF_BGL_FRAME2_M,0,0,0);

	APP_ArcFileVramLoad(wk->sys->bgl,wk->heapID,
		handle,arcID,NARC_pgmap_gra_guide001_ncgr+skin,
		GF_BGL_FRAME2_S,0,0,0);
	APP_ArcFileVramLoad(wk->sys->bgl,wk->heapID,
		handle,arcID,NARC_pgmap_gra_gmap_ncgr,
		GF_BGL_FRAME3_S,0,0,0);

	//スクリーン転送
	wk->pSBufGuide = ArcUtil_HDL_ScrnDataGet(handle,
			NARC_pgmap_gra_guide001_nscr+skin, FALSE,&wk->pSGuide,wk->heapID);
	wk->pSBufMap = ArcUtil_HDL_ScrnDataGet(handle,
			NARC_pgmap_gra_map_nscr, FALSE,&wk->pSMap,wk->heapID);
	wk->pSBufGMap = ArcUtil_HDL_ScrnDataGet(handle,
			NARC_pgmap_gra_gmap_nscr, FALSE,&wk->pSGMap,wk->heapID);
	wk->pSBufFrm = ArcUtil_HDL_ScrnDataGet(handle,
			NARC_pgmap_gra_frm001_nscr+skin, FALSE,&wk->pSFrm,wk->heapID);
	wk->pSBufMk0 = ArcUtil_HDL_ScrnDataGet(handle,
			NARC_pgmap_gra_mark1001_nscr+skin, FALSE,&wk->pSMk0,wk->heapID);
	wk->pSBufMk1 = ArcUtil_HDL_ScrnDataGet(handle,
			NARC_pgmap_gra_mark2001_nscr+skin, FALSE,&wk->pSMk1,wk->heapID);

	//ハンドル閉じる
	ArchiveDataHandleClose( handle );

	//スクリーン転送
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_M);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_M);
}

/**
 *	@brief	マップのBGリソース開放
 */
static void pgmap_2DResRelease(PGMAP_SYS_WORK* wk)
{
	sys_FreeMemoryEz(wk->pSBufMk1);
	sys_FreeMemoryEz(wk->pSBufMk0);
	sys_FreeMemoryEz(wk->pSBufFrm);
	sys_FreeMemoryEz(wk->pSBufGMap);
	sys_FreeMemoryEz(wk->pSBufMap);
	sys_FreeMemoryEz(wk->pSBufGuide);
}

/**
 *	@brief	BmpWin初期化
 */
static void pgmap_BmpWinAdd(PGMAP_SYS_WORK* wk)
{
	int i;

	static const struct{
		u8 frm,px,py,sx,sy,pal;
		u16	cgx;
	}windat[] = {
	 { BMPL_G01_FRM,BMPL_G01_PX,BMPL_G01_PY,BMPL_G01_SX,BMPL_G01_SY,
	   BMPL_G01_PAL,BMPL_G01_CGX},
	 { BMPL_G02_FRM,BMPL_G02_PX,BMPL_G02_PY,BMPL_G02_SX,BMPL_G02_SY,
	   BMPL_G02_PAL,BMPL_G02_CGX},
	 { BMPL_G03_FRM,BMPL_G03_PX,BMPL_G03_PY,BMPL_G03_SX,BMPL_G03_SY,
	   BMPL_G03_PAL,BMPL_G03_CGX},
	 { BMPL_MK01_FRM,BMPL_MK01_PX,BMPL_MK01_PY,BMPL_MK01_SX,BMPL_MK01_SY,
	   BMPL_MK01_PAL,BMPL_MK01_CGX},
	 { BMPL_MK02_FRM,BMPL_MK02_PX,BMPL_MK02_PY,BMPL_MK02_SX,BMPL_MK02_SY,
	   BMPL_MK02_PAL,BMPL_MK02_CGX},
	 { BMPL_MK03_FRM,BMPL_MK03_PX,BMPL_MK03_PY,BMPL_MK03_SX,BMPL_MK03_SY,
	   BMPL_MK03_PAL,BMPL_MK03_CGX},
	 { BMPL_MK04_FRM,BMPL_MK04_PX,BMPL_MK04_PY,BMPL_MK04_SX,BMPL_MK04_SY,
	   BMPL_MK04_PAL,BMPL_MK04_CGX},
	 { BMPL_ME01_FRM,BMPL_ME01_PX,BMPL_ME01_PY,BMPL_ME01_SX,BMPL_ME01_SY,
	   BMPL_ME01_PAL,BMPL_ME01_CGX},
	};
	for(i = 0;i <= WIN_ME01;i++){
		GF_BGL_BmpWinAdd(
			wk->sys->bgl, &wk->win[i], windat[i].frm,
			windat[i].px, windat[i].py, windat[i].sx, windat[i].sy, windat[i].pal, windat[i].cgx );
		GF_BGL_BmpWinDataFill(&(wk->win[i]),FBMP_COL_NULL);
	}

	//FontOam用BMPWinを作成
	GF_BGL_BmpWinInit(&(wk->win[WIN_ME02]));
	GF_BGL_BmpWinObjAdd(wk->sys->bgl,
		&(wk->win[WIN_ME02]),BMPL_ME02_SX,BMPL_ME02_SY,BMPL_ME02_CGX,0);
	GF_BGL_BmpWinObjDataFill(&(wk->win[WIN_ME02]),FBMP_COL_NULL);
}

/*
 *	@brief	BmpWin開放
 */
static void pgmap_BmpWinDel(PGMAP_SYS_WORK* wk)
{
	int i = 0;

	for(i = 0;i < WIN_ME02;i++){
		GF_BGL_BmpWinOff(&wk->win[i]);
		GF_BGL_BmpWinDel(&wk->win[i]);
	}
	GF_BGL_BmpWinDel(&wk->win[WIN_ME02]);
}

/**
 *	@brief	メッセージデータ初期化
 */
static void pgmap_MsgDataInit(PGMAP_SYS_WORK* wk)
{
	wk->msgDat.gMan = MSGMAN_Create(MSGMAN_TYPE_NORMAL,ARC_MSG,
			NARC_msg_pgmap_guide_dat,wk->heapID);

	wk->msgDat.wset = WORDSET_CreateEx(2,WORDSET_PGMAP_BUFLEN,wk->heapID);
	wk->msgDat.tmp = STRBUF_Create(WORDSET_PGMAP_BUFLEN,wk->heapID);
	wk->msgDat.area[0] = MSGMAN_AllocString(wk->msgDat.gMan,msg_area_west);
	wk->msgDat.area[1] = MSGMAN_AllocString(wk->msgDat.gMan,msg_area_east);
	wk->msgDat.place = STRBUF_Create((MAPNAME_MAX+BUFLEN_EOM_SIZE)*2,wk->heapID);
	wk->msgDat.pms_word = MSGMAN_AllocString(wk->msgDat.gMan,msg_mk_word);

	//メッセージスピード取得
//	wk->msgDat.msg_spd = CONFIG_GetMsgPrintSpeed(wk->param->configSave);
	wk->msgDat.msg_spd = 2;
}

/*
 *	@brief	メッセージデータ開放
 */
static void pgmap_MsgDataRelease(PGMAP_SYS_WORK* wk)
{
	STRBUF_Delete(wk->msgDat.pms_word);
	STRBUF_Delete(wk->msgDat.place);
	STRBUF_Delete(wk->msgDat.area[1]);
	STRBUF_Delete(wk->msgDat.area[0]);
	STRBUF_Delete(wk->msgDat.tmp);
	WORDSET_Delete(wk->msgDat.wset);

	MSGMAN_Delete(wk->msgDat.gMan);
}

/**
 *	@brief	カーソル移動パラメータ登録
 */
static void pgmap_CMoveParamInit(PGMAP_SYS_WORK* wk)
{
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	static const CURSORMV_DAT_UNIT pgmk1_keycnt[] = {
	//left,right,up,down,
	 {0, 3,1, 4,4, EACT_MARK_PX,EACT_MARK_PY,-6,6,-6,6},
	 {1, 0,2, 5,5, EACT_PLATE_PX,EACT_PLATE_PY, 6,10*8,-6,6},
	 {2, 1,3, 6,6, EACT_MARK_PX+EACT_MARK_SX,EACT_MARK_PY,-6,6,-6,6},
	 {3, 2,0, 8,7,	EACT_PLATE_PX+EACT_PLATE_SX,EACT_PLATE_PY, 6,10*8,-6,6},
	 {4, 7,5, 0,0,	EACT_MARK_PX,EACT_MARK_PY+EACT_MARK_SY,-6,6,-6,6},
	 {5, 4,6, 1,1,	EACT_PLATE_PX,EACT_PLATE_PY+EACT_PLATE_SY, 6,10*8,-6,6},
	 {6, 5,7, 2,2,	EACT_MARK_PX+EACT_MARK_SX,EACT_MARK_PY+EACT_MARK_SY,-6,6,-6,6},
	 {7, 6,4, 3,8,	EACT_PLATE_PX+EACT_PLATE_SX,EACT_PLATE_PY+EACT_PLATE_SY, 6,10*8,-6,6},
	 {8, -1,-1, 7,3,	208,84, -16,16,-9,3},
	};

	static const CURSORMV_DAT_UNIT pgmk2_keycnt[] = {
	 {0, 7,1,-1,-1,	EACT_MKDEF_PX+0*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {1, 0,2,-1,-1,	EACT_MKDEF_PX+1*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {2, 1,3,-1,-1,	EACT_MKDEF_PX+2*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {3, 2,4,-1,-1,	EACT_MKDEF_PX+3*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {4, 3,5,-1,-1,	EACT_MKDEF_PX+4*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {5, 4,6,-1,-1,	EACT_MKDEF_PX+5*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {6, 5,7,-1,-1,	EACT_MKDEF_PX+6*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	 {7, 6,0,-1,-1,	EACT_MKDEF_PX+7*EACT_MKDEF_SX,EACT_MKDEF_PY,-8,8,-8,8},
	};
	static const CURSORMV_DAT_UNIT pgmk3_keycnt[] = {
	 {0, -1,-1,-1,-1,	9*8,10*8+4,-18,18,-12,6},
	};

	//システムボタンカーソルパラメータ登録
	CursorMvMan_EntryParamUnit(wk->sys->curMan,pgmk1_keycnt,NELEMS(pgmk1_keycnt),
		0,CURMV_OAM_CLACT,wk->heapID,
		(void*)pAct[EACT_CLT1].act,(void*)pAct[EACT_CLB1].act,
		(void*)pAct[EACT_CRT1].act,(void*)pAct[EACT_CRB1].act);
	CursorMvMan_EntryParamUnit(wk->sys->curMan,pgmk2_keycnt,NELEMS(pgmk2_keycnt),
		0,CURMV_OAM_CLACT,wk->heapID,
		(void*)pAct[EACT_CLT2].act,(void*)pAct[EACT_CLB2].act,
		(void*)pAct[EACT_CRT2].act,(void*)pAct[EACT_CRB2].act);
	CursorMvMan_EntryParamUnit(wk->sys->curMan,pgmk3_keycnt,NELEMS(pgmk3_keycnt),
		0,CURMV_OAM_CLACT,wk->heapID,
		(void*)pAct[EACT_CLT2].act,(void*)pAct[EACT_CLB2].act,
		(void*)pAct[EACT_CRT2].act,(void*)pAct[EACT_CRB2].act);

	//いったん非表示
	CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_APP_PARAM1,FALSE);
	CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_APP_PARAM2,FALSE);
	CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_APP_PARAM3,FALSE);

	//カレントを指定
	if(wk->call_mode == PGMAP_CALL_MARK){
		CursorMvMan_SetCurrent(wk->sys->curMan,PGKM_APP_PARAM1,wk->ret.word_pos*2+1);
	}else{
		CursorMvMan_SetCurrent(wk->sys->curMan,PGKM_APP_PARAM1,0);
	}
}

/*
 *	@brief	カーソル移動パラメータ削除
 */
static void pgmap_CMoveParamRelease(PGMAP_SYS_WORK* wk)
{
	int i;

	for(i = 0;i < 3;i++){
		CursorMvMan_DeleteParam(wk->sys->curMan,PGKM_APP_PARAM1+i);
	}
}

/**
 *	@brief	パレットアニメワークセット
 */
static void pgmap_PalAnmWorkSet(PGMAP_SYS_WORK* wk,u8 skin)
{
	int	arcID;
	ARCHANDLE* handle;

	//アーカイブハンドル取得
	arcID = ARC_PGMAP_GRA;
	handle = ArchiveDataHandleOpen(ARC_PGMAP_GRA,wk->heapID);

	//パレットアニメワークに登録
	PaletteWorkSetEx_ArcHandle(wk->sys->palAnm,handle,
		NARC_pgmap_gra_bgd001_nclr+skin,wk->heapID,
		FADE_MAIN_BG,FADE_PAL_ONE_SIZE*PGAPP_PALNUM_M,16*PGAPP_PALIDX_M,16*PGAPP_PALIDX_M);
	PaletteWorkSetEx_ArcHandle(wk->sys->palAnm,handle,
		NARC_pgmap_gra_bgu001_nclr+skin,wk->heapID,
		FADE_SUB_BG,FADE_PAL_ONE_SIZE*PGAPP_PALNUM_S,16*PGAPP_PALIDX_S,16*PGAPP_PALIDX_S);
	//パレットアニメワークに登録
	PaletteWorkSetEx_ArcHandle(wk->sys->palAnm,handle,
		NARC_pgmap_gra_oam_nclr,wk->heapID,
		FADE_MAIN_OBJ,FADE_PAL_ONE_SIZE*(PGAPPOAM_PALNUM_M-1),16*PGAPPOAM_PALIDX_M,0);
	PaletteWorkSetEx_ArcHandle(wk->sys->palAnm,handle,
		NARC_pgmap_gra_oam_nclr,wk->heapID,
		FADE_SUB_OBJ,FADE_PAL_ONE_SIZE*(PGAPPOAM_PALNUM_S-1),16*PGAPPOAM_PALIDX_S,0);

	//ブラックアウト状態に変更しておく
	PaletteTrans_AutoSet(wk->sys->palAnm,TRUE);
	SoftFadePfd(wk->sys->palAnm,FADE_MAIN_BG,16*PGAPP_PALIDX_M,16*PGAPP_PALNUM_M,16,0x0000);
	SoftFadePfd(wk->sys->palAnm,FADE_MAIN_OBJ,16*PGAPPOAM_PALIDX_M,16*PGAPPOAM_PALNUM_M,16,0x0000);
	PaletteFadeTrans( wk->sys->palAnm );
	PaletteTrans_AutoSet(wk->sys->palAnm,FALSE);

	//ハンドル閉じる
	ArchiveDataHandleClose( handle );
}

/**
 *	@brief	マップのアクターリソース初期化
 */
static void pgmap_ActResInit(PGMAP_SYS_WORK* wk)
{
	//リソース確保
	PGear_ActorResInit(wk->sys,PGAPP_MODE_MAP);
	//ワークマネージャ作成
	wk->pActWMan = PGActWorkMan_Create(PGMAP_ACTMAX,wk->heapID);

	//サブサーフェースの距離を設定
	CLACT_U_SetSubSurfaceMatrix(CATS_EasyRenderGet(wk->sys->pActSys),0,
			SUB_SURFACE_Y+FX32_CONST(PGMAP_SUBSURFACE_Y));

	//FontOamマネージャを作成
	wk->pFOamSys = FONTOAM_SysInit(MEDIT_PLATE_MAX,wk->heapID);
}

/**
 *	@brief	マップのアクターリソース開放
 */
static void pgmap_ActResRelease(PGMAP_SYS_WORK* wk)
{
	//サブサーフェースの距離を設定
	CLACT_U_SetSubSurfaceMatrix(CATS_EasyRenderGet(wk->sys->pActSys),0,SUB_SURFACE_Y);

	//FontOamマネージャを削除
	FONTOAM_SysDelete(wk->pFOamSys);

	//ワークマネージャ開放
	PGActWorkMan_Release(wk->pActWMan);
	//リソース開放
	PGear_ActorResRelease(wk->sys);
}


/**
 *	@brief	ノーマルOBJの作成
 */
static void pgmap_MakeNormalActor(PGMAP_SYS_WORK* wk)
{
	int i;
	u16	idx;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	static const TCATS_OBJECT_ADD_PARAM	ActAddParam[] =
	{
		{	// 上画面ガイドマーク
			RESACT_MARK,	//ID
			NACT_HERO_PX, NACT_HERO_PY, 0,	//x,y,z
			ANM_MK_ICON, 0, PGSYSOAM_PALNUM_M, NNS_G2D_VRAM_TYPE_2DSUB,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// 上画面ガイドマーク 再戦トレーナーアイコン
			RESACT_MARK,	//ID
			NACT_REVENGE_PX, NACT_REVENGE_PY+PGMAP_SUBSURFACE_Y, 0,	//x,y,z
			ANM_MK_REVENGE, 0, PGSYSOAM_PALNUM_M, NNS_G2D_VRAM_TYPE_2DSUB,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// カーソル
			RESACT_HERO,	//ID
			NACT_CUR_PX, NACT_CUR_PY, 0,	//x,y,z
			ANM_H_CURSOR, 1, PGSYSOAM_PALNUM_M+0, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// 主人公
			RESACT_HERO,	//ID
			NACT_HERO_PX, NACT_HERO_PY, 0,	//x,y,z
			ANM_H_HERO, 1, PGSYSOAM_PALNUM_M, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// ポケモン
			RESACT_HERO,	//ID
			NACT_HERO_PX, NACT_HERO_PY, 0,	//x,y,z
			ANM_H_POKE, 1, PGSYSOAM_PALNUM_M, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
	};

	//上画面ガイドアイコン
	for(i = 0;i < 4;i++){
		PGActWorkMan_ListAdd(wk->pActWMan,
					CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[0]));
		CATS_ObjectPosSet(pAct[NACT_MARK1+i].act,
				NACT_MARK_PX+NACT_MARK_SX*(i%2),
				NACT_MARK_PY+(i/2)*NACT_MARK_SY+PGMAP_SUBSURFACE_Y);
		CATS_ObjectBGPriSet(pAct[NACT_MARK1+i].act,0);
	}
	//上画面再戦トレーナーアイコン
	PGActWorkMan_ListAdd(wk->pActWMan,
		CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[1]));
	CATS_ObjectBGPriSet(pAct[NACT_REV].act,0);

	//カーソル
	PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[2]));
	//主人公
	PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[3]));

	//ポケモン
	for(i = 0;i < MOVE_POKE_MAX;i++){
		PGActWorkMan_ListAdd(wk->pActWMan,
				CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[4]));
		CLACT_AnmFrameChg(pAct[NACT_POKE1+i].act, FX32_CONST(i));
	}

	//初期位置セット
	for(i = 0;i < NACT_NUM;i++){
		idx = NACT_START+i;
		CATS_ObjectPosGet(pAct[idx].act,&pAct[idx].pos.x,&pAct[idx].pos.y);
		CLACT_SetDrawFlag(pAct[idx].act, FALSE);
	}
	CLACT_SetAnmFlag(pAct[NACT_CURSOR].act, TRUE);
	CLACT_SetAnmFlag(pAct[NACT_HERO].act, FALSE);
	CLACT_AnmFrameSet(pAct[NACT_HERO].act,wk->sys->param->player_sex);

	//カーソルはアフィンフラグを立てておく
	CLACT_SetAffineParam(pAct[NACT_CURSOR].act,CLACT_AFFINE_DOUBLE);

//	CLACT_AnmFrameChg(wk->pCAW_cur,FX32_ONE);	//アニメパターンリセット
//	CLACT_ObjModeSet(wk->pAct[NACT_HERO], GX_OAM_MODE_XLU);
//	CLACT_PaletteNoChg(wk->pAct[NACT_CURSOR],4);		//パレット指定

}

/**
 *	@brief	マップマークアイコンの作成
 */
static void pgmap_MakeMarkActor(PGMAP_SYS_WORK* wk)
{
	u16	i,idx;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	static const TCATS_OBJECT_ADD_PARAM	ActAddParam[] =
	{
		{	// カーソル
			RESACT_HERO,	//ID
			0,0, 0,	//x,y,z
			ANM_H_MARK, 1, PGSYSOAM_PALNUM_M+0, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
	};

	for(i = 0;i < MKACT_NUM;i++){
		//ワークリストに登録
		idx = PGActWorkMan_ListAdd(wk->pActWMan,
					CATS_ObjectAdd( wk->sys->pActSys,
					wk->sys->pActRes,
					&ActAddParam[0])
				);

		CATS_ObjectPosGet(pAct[idx].act,&pAct[idx].pos.x,&pAct[idx].pos.y);
		CLACT_SetDrawFlag(pAct[idx].act, FALSE);
		CLACT_SetAnmFlag(pAct[idx].act, FALSE);
	}
}


/**
 *	@brief	マーカー編集画面FontOamObjの作成
 */
static void pgmap_MakeMEditFontOam(PGMAP_SYS_WORK* wk)
{
	FONTOAM_INIT finit;
	int vram_size;
//	int font_len, char_len;
	int i;

	//OAMDATAを作成
	wk->pFOamData = FONTOAM_OAMDATA_Make(&(wk->win[WIN_ME02]), wk->heapID);
	vram_size = FONTOAM_OAMDATA_NeedCharSize(wk->pFOamData, NNS_G2D_VRAM_TYPE_2DMAIN);

	GF_STR_PrintColor( &(wk->win[WIN_ME02]),FONT_SYSTEM,
						wk->msgDat.area[1],
						0,0,MSG_NO_PUT,GF_PRINTCOLOR_MAKE(1,2,0),NULL );

	finit.fontoam_sys = wk->pFOamSys;
	finit.bmp = &(wk->win[WIN_ME02]);
	finit.clact_set = CATS_GetClactSetPtr(wk->sys->pActRes);
	finit.pltt = CATS_PlttProxy(wk->sys->pActRes, 0);
	finit.bg_pri = MKACT_BGPRI;
	finit.soft_pri = MKACT_SPRI_DEF-1;
	finit.x = FOAM_PLATE_OFSX;
	finit.y = FOAM_PLATE_OFSY;
	finit.draw_area = NNS_G2D_VRAM_TYPE_2DMAIN;
	finit.heap = wk->heapID;

	for(i = 0;i < MEDIT_PLATE_MAX;i++){
		CharVramAreaAlloc(vram_size,
			CHARM_CONT_AREACONT, NNS_G2D_VRAM_TYPE_2DMAIN,&(wk->pFontOam[i].cma));

		finit.char_ofs = wk->pFontOam[i].cma.alloc_ofs;
		finit.parent = wk->pActWMan->pAct[EACT_PLATE1+i].act;

		wk->pFontOam[i].foam = FONTOAM_OAMDATA_Init(&finit, wk->pFOamData);
		FONTOAM_SetDrawFlag(wk->pFontOam[i].foam,FALSE);
		FONTOAM_SetPaletteNo(wk->pFontOam[i].foam,EACT_PLATE_PAL);
	}
}

/**
 *	@brief	マーカー編集画面FontOamObjの削除
 */
static void pgmap_DelMEditFontOam(PGMAP_SYS_WORK* wk)
{
	int i;

	for(i = 0;i < MEDIT_PLATE_MAX;i++){
		FONTOAM_OAMDATA_Delete(wk->pFontOam[i].foam);
		CharVramAreaFree(&(wk->pFontOam[i].cma));
		wk->pFontOam[i].foam = NULL;
	}
	FONTOAM_OAMDATA_Free(wk->pFOamData);
}


/**
 *	@brief	マーカー編集画面OBJの作成
 */
static void pgmap_MakeMEditActor(PGMAP_SYS_WORK* wk)
{
	u16	i,idx;
	PGEAR_ACT_WORK*  pAct= wk->pActWMan->pAct;

	static const TCATS_OBJECT_ADD_PARAM	ActAddParam[] =
	{
		{	// 矢印
			RESACT_HERO,	//ID
			0,0, 0,	//x,y,z
			ANM_H_ARROW, MKACT_SPRI_DEF, PGSYSOAM_PALNUM_M+0, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// 下画面アプリ用カーソル
			RESACT_HERO,	//ID
			0,0, 0,	//x,y,z
			ANM_MM_PLATE, MKACT_SPRI_DEF, PGSYSOAM_PALNUM_M+2, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// した画面アイコン
			RESACT_MARK,	//ID
			0,0, 0,	//x,y,z
			ANM_MK_ICON, MKACT_SPRI_DEF, PGSYSOAM_PALNUM_M+0, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
		{	// した画面プレート
			RESACT_MEMO,	//ID
			0,0, 0,	//x,y,z
			ANM_MM_PLATE, MKACT_SPRI_DEF, PGSYSOAM_PALNUM_M+1, NNS_G2D_VRAM_TYPE_2DMAIN,	//anmNO,pri,pal,d_area
			0, 0, 0, 0	//prm1,prm2,prm3,prm4
		},
	};

	//矢印
	PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[0]));
	PGActWork_PosSet(&(pAct[EACT_ARROW]),EACT_ARROW_PX,EACT_ARROW_PY);
	CLACT_SetDrawFlag(pAct[EACT_ARROW].act, TRUE);

	//下画面用カーソル
	for(i = 0;i < 8;i++){
		PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[1]));
		PGActWork_PosSet(&pAct[EACT_CLT1+i],0,0);
		CLACT_AnmChg(pAct[EACT_CLT1+i].act,(i%4)+ANM_H_MKCUR_LT);
		CLACT_SetAnmFlag(pAct[EACT_CLT1+i].act, TRUE);
		CLACT_SetDrawFlag(pAct[EACT_CLT1+i].act, FALSE);
		CLACT_BGPriorityChg(pAct[EACT_CLT1+i].act,MKACT_BGPRI);
		//ポジションは自前で制御する
		pAct[EACT_CLT1+i].automv_fook = TRUE;
	}
	//マーカー初期位置
	for(i = 0;i < 4;i++){
		//ワークリストに登録
		PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[2]));
		PGActWork_PosSet(&pAct[EACT_MARK1+i],
			EACT_MARK_PX+(i%2)*EACT_MARK_SX,EACT_MARK_PY+(i/2)*EACT_MARK_SY);
		CLACT_BGPriorityChg(pAct[EACT_MARK1+i].act,MKACT_BGPRI);
	}
	//プレート初期位置
	for(i = 0;i < 4;i++){
		//ワークリストに登録
		PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[3]));
		PGActWork_PosSet(&pAct[EACT_PLATE1+i],
			EACT_PLATE_PX+(i%2)*EACT_PLATE_SX,EACT_PLATE_PY+(i/2)*EACT_PLATE_SY);
		CLACT_BGPriorityChg(pAct[EACT_PLATE1+i].act,MKACT_BGPRI);
	}
	//デフォルトマーク初期位置
	for(i = 0;i < 8;i++){
		//ワークリストに登録
		PGActWorkMan_ListAdd(wk->pActWMan,
			CATS_ObjectAdd( wk->sys->pActSys,wk->sys->pActRes,&ActAddParam[2]));
		PGActWork_PosSet(&pAct[EACT_MKDEF1+i],
			EACT_MKDEF_PX+i*EACT_MKDEF_SX,EACT_MKDEF_PY);
		CLACT_AnmFrameSet(pAct[EACT_MKDEF1+i].act,i);
		CLACT_BGPriorityChg(pAct[EACT_MKDEF1+i].act,MKACT_BGPRI);
	}
	for(i = EACT_MARK1;i <= EACT_MKDEF8;i++){
		CLACT_SetDrawFlag(pAct[i].act, TRUE);
		CLACT_SetAnmFlag(pAct[i].act, FALSE);
	}
	CLACT_SetAnmFlag(pAct[EACT_ARROW].act, TRUE);

	//座標反映
	PGActWorkMan_AllPosUpdate(wk->pActWMan);

	//FontOam作成
	pgmap_MakeMEditFontOam(wk);
}

/**
 *	@brief	マーク編集画面固有のアクターを削除
 */
static void pgmap_DelMEditActor(PGMAP_SYS_WORK* wk)
{
	pgmap_DelMEditFontOam(wk);
	PGActWorkMan_ListDelIdxAfter(wk->pActWMan,NACT_MAX);
}


/**
 *	@biref	マップの　コモンアクター作成
 */
static void pgmap_MakeActor(PGMAP_SYS_WORK* wk)
{
	pgmap_MakeNormalActor(wk);
}

/**
 *	@brief	非コモンOBJ削除
 */
static void pgmap_DelUncommonActor(PGMAP_SYS_WORK* wk)
{
	PGActWorkMan_ListDelIdxAfter(wk->pActWMan,NACT_MAX);
}

/**
 *	@brief	マップ　アクター全削除
 */
static void pgmap_DelActorAll(PGMAP_SYS_WORK* wk)
{
	PGActWorkMan_ListDelAll(wk->pActWMan);
}

/*
 *	@brief	初期画面描画
 */
static void pgmap_MapIniDraw(PGMAP_SYS_WORK* wk)
{
	int i;
	s16	cx,cy;
	PGEAR_ACT_WORK* pAct = wk->pActWMan->pAct;

	//GFルールでは直接呼ぶべきではないが、ポケギアでは特別に呼ぶ
	//2/3面をAffine拡張BGに変更
	GX_SetGraphicsMode( GX_DISPMODE_GRAPHICS, GX_BGMODE_5,GX_BG0_AS_2D );

	//メインBG2,3のキャラクタベースを0x00000に変更
	for(i = 0;i < 2;i++){
		GF_BGL_BGControlReset(wk->sys->bgl,GF_BGL_FRAME2_M+i,BGL_RESET_MODE,GF_BGL_MODE_256X16);
		GF_BGL_BGControlReset(wk->sys->bgl,GF_BGL_FRAME2_M+i,BGL_RESET_CHRBASE,GX_BG_CHARBASE_0x10000);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M+i, GF_BGL_SCROLL_X_SET, 0);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M+i, GF_BGL_SCROLL_Y_SET, 0);
	}

	//ブレンド設定
	G2_SetBlendAlpha(GX_BLEND_PLANEMASK_BG2,GX_BLEND_PLANEMASK_BG3,MAP_ALPHA_SECOND,MAP_ALPHA_FIRST);

	//BG0は表示設定
	GF_BGL_VisibleSet(GF_BGL_FRAME0_M,VISIBLE_ON);

	//いったんスクリーンをクリア
	for(i = 0;i < 3;i++){
		GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME1_M+i);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M+i, GF_BGL_SCROLL_X_SET, 0);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME1_M+i, GF_BGL_SCROLL_Y_SET, 0);
	}

	//キーとタッチ切替時に呼ぶ関数を設定
	wk->sys->to_akey_func = PGMapSub_ToKeyChangeMap;
	wk->sys->to_touch_func = PGMapSub_ToTouchChangeMap;

	//初期スクロール位置取得
	PGMapSub_MapBGIniScrollCalc(wk);
	PGMapSub_MapBGScrollSet(wk,&wk->cScrl);

	//フレーム書き込み
	GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME1_M,
		0,0,32,20,
		wk->pSFrm->rawData,
		0,0,
		wk->pSFrm->screenWidth/8,wk->pSFrm->screenHeight/8);

	//タウンマップBGの初期表示
	PGMapSub_DrawTownMap(wk);

	PGMapSub_MapPanelStChange(wk,1,wk->f_affine);

	//ガイド初期表示
	GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME2_S,
		0,7,32,17,
		wk->pSGuide->rawData,
		0,7,
		wk->pSGuide->screenWidth/8,wk->pSGuide->screenHeight/8);

	PGMapSub_GetNowZone(wk,&(wk->cZone),wk->cTarget.x,wk->cTarget.z);
	PGMapSub_DrawGuide(wk,FALSE);

	PGMapSub_DrawTargetZoneHilight(wk,TRUE);

	//アクター追加
	pgmap_MakeMarkActor(wk);

	//タウン・マーキングアイコンの初期描画
	PGMapSub_MarkPosViewSet(wk,0);

	//MapOBJの状態変更
	PGMapSub_MapObjSetIOMark(wk,1);

	//キー操作モードによって、描画状態を変更
	if(wk->sys->control == PGCONT_SYS){
		CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_SYS_PARAM,TRUE);
		CLACT_SetDrawFlag(pAct[NACT_CURSOR].act,FALSE);
	}else{
		CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,0,FALSE);
		CLACT_SetDrawFlag(pAct[NACT_CURSOR].act,TRUE);
	}
	CursorMvMan_SetCurrent(wk->sys->curMan,PGKM_SYS_PARAM,PGFrame_GetSCurModePosNo(wk->sys));

	if(wk->sys->call_end){	//上画面ガイドの初期スクロール値セット
		PGMapSub_GuideScrollSet(wk,0);
	}
	PGActWorkMan_AllPosUpdate(wk->pActWMan);

	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_S);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME3_S);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_M);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_M);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME3_M);

}

/*
 *	@brief	マーク画面初期描画
 */
static void pgmap_MarkViewIniDraw(PGMAP_SYS_WORK* wk)
{
	int i;

	//GFルールでは直接呼ぶべきではないが、ポケギアでは特別に呼ぶ
	//全面テキストBGに変更
	GX_SetGraphicsMode( GX_DISPMODE_GRAPHICS, GX_BGMODE_0,GX_BG0_AS_2D );

	//メインBG2,3のキャラクタベースを0x00000に変更
	for(i = 0;i < 2;i++){
		GF_BGL_BGControlReset(wk->sys->bgl,GF_BGL_FRAME2_M+i,BGL_RESET_MODE,GF_BGL_MODE_TEXT);
		GF_BGL_BGControlReset(wk->sys->bgl,GF_BGL_FRAME2_M+i,BGL_RESET_CHRBASE,GX_BG_CHARBASE_0x00000);
		GF_BGL_BGControlReset(wk->sys->bgl,GF_BGL_FRAME2_M+i,BGL_RESET_COLOR,GX_BG_COLORMODE_16);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M+i, GF_BGL_SCROLL_X_SET, 0);
		GF_BGL_ScrollSet( wk->sys->bgl,GF_BGL_FRAME2_M+i, GF_BGL_SCROLL_Y_SET, 0);
	}

	//BG0は隠す
	GF_BGL_VisibleSet(GF_BGL_FRAME0_M,VISIBLE_OFF);

	//マップ画面のブレンド設定解除
	G2_SetBlendAlpha(GX_BLEND_PLANEMASK_NONE,GX_BLEND_PLANEMASK_NONE,0,0);

	//いったんスクリーンをクリア
	for(i = 0;i < 3;i++){
		GF_BGL_ScrClear(wk->sys->bgl,GF_BGL_FRAME1_M+i);
	}

	//初期スクリーンを書き込み
	GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME2_M,
		0,0,32,14,wk->pSMk0->rawData,0,0,
		wk->pSMk0->screenWidth/8,wk->pSMk0->screenHeight/8);
	GF_BGL_ScrWriteExpand(wk->sys->bgl,GF_BGL_FRAME3_M,
		0,0,32,24,wk->pSMk1->rawData,0,0,
		wk->pSMk1->screenWidth/8,wk->pSMk1->screenHeight/8);

	GF_BGL_VisibleSet(GF_BGL_FRAME2_M,VISIBLE_ON);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME1_M);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME2_M);
	GF_BGL_LoadScreenV_Req(wk->sys->bgl,GF_BGL_FRAME3_M);

	//アクター追加
	pgmap_MakeMEditActor(wk);

	//カーソル制御パラメータ追加
	pgmap_CMoveParamInit(wk);

	//MapOBJの状態変更
	PGMapSub_MapObjSetIOMark(wk,0);

	if(wk->call_mode == PGMAP_CALL_MARK){
		//現ターゲットゾーンデータを取得
		PGMapSub_GetNowZone(wk,&(wk->cZone),wk->ret.tx,wk->ret.tz);

		//選択カーソルの表示状態制御
		if(wk->sys->key_mode != APP_KTST_TOUCH){
			CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_APP_PARAM1,TRUE);
		}else{
			CursorMvMan_SetCursorDrawFlag(wk->sys->curMan,PGKM_APP_PARAM1,FALSE);
		}
	}

	//初期ガイド描画
	PGMapSub_DrawEditGuide(wk,TRUE);

	//操作の初期ステータスをセット
	wk->mkedit_st = MKEDIT_SEL;
	wk->mkedit_view = 0;

	//キーとタッチ切替時に呼ぶ関数を設定
	wk->sys->to_akey_func = PGMapSub_ToKeyChangeMark;
	wk->sys->to_touch_func = PGMapSub_ToTouchChangeMark;
}

/**
 *	@brief	マーキング画面遷移状態セット
 */
static void pgmap_MarkViewDataSet(PGMAP_SYS_WORK* wk,BOOL on_f)
{
	if(on_f){

	}else{
		wk->ret.word_pos = 0;
		wk->call_mode = PGMAP_CALL_MAP;	//モードを元に戻す
	}
}